﻿using System;
using System.ComponentModel;

namespace HalconDotNet
{
	/// <summary>Represents an instance of an XLD parallel object(-array).</summary>
	// Token: 0x02000077 RID: 119
	[Serializable]
	public class HXLDPara : HXLD
	{
		/// <summary>Create an uninitialized iconic object</summary>
		// Token: 0x06001CC5 RID: 7365 RVA: 0x000ABEF9 File Offset: 0x000AA0F9
		public HXLDPara() : base(HObjectBase.UNDEF, false)
		{
		}

		// Token: 0x06001CC6 RID: 7366 RVA: 0x000B217A File Offset: 0x000B037A
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HXLDPara(IntPtr key) : this(key, true)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001CC7 RID: 7367 RVA: 0x000B2190 File Offset: 0x000B0390
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HXLDPara(IntPtr key, bool copy) : base(key, copy)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001CC8 RID: 7368 RVA: 0x000B21A6 File Offset: 0x000B03A6
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HXLDPara(HObject obj) : base(obj)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001CC9 RID: 7369 RVA: 0x000B21BB File Offset: 0x000B03BB
		private void AssertObjectClass()
		{
			HalconAPI.AssertObjectClass(this.key, "xld_para");
		}

		/// <summary>Returns the iconic object(s) at the specified index</summary>
		// Token: 0x17000069 RID: 105
		public HXLDPara this[HTuple index]
		{
			get
			{
				return this.SelectObj(index);
			}
		}

		// Token: 0x06001CCB RID: 7371 RVA: 0x000B21D6 File Offset: 0x000B03D6
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static int LoadNew(IntPtr proc, int parIndex, int err, out HXLDPara obj)
		{
			obj = new HXLDPara(HObjectBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		/// <summary>
		///   Extract parallel XLD polygons enclosing a homogeneous area.
		///   Instance represents: Input XLD parallels.
		/// </summary>
		/// <param name="image">Corresponding gray value image.</param>
		/// <param name="extParallels">Extended XLD parallels.</param>
		/// <param name="quality">Minimum quality factor (measure of parallelism). Default: 0.4</param>
		/// <param name="minGray">Minimum mean gray value. Default: 160</param>
		/// <param name="maxGray">Maximum mean gray value. Default: 220</param>
		/// <param name="maxStandard">Maximum allowed standard deviation. Default: 10.0</param>
		/// <returns>Modified XLD parallels.</returns>
		// Token: 0x06001CCC RID: 7372 RVA: 0x000B21F0 File Offset: 0x000B03F0
		public HXLDModPara ModParallelsXld(HImage image, out HXLDExtPara extParallels, HTuple quality, int minGray, int maxGray, HTuple maxStandard)
		{
			IntPtr proc = HalconAPI.PreCall(39);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, quality);
			HalconAPI.StoreI(proc, 1, minGray);
			HalconAPI.StoreI(proc, 2, maxGray);
			HalconAPI.Store(proc, 3, maxStandard);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(quality);
			HalconAPI.UnpinTuple(maxStandard);
			HXLDModPara result;
			num = HXLDModPara.LoadNew(proc, 1, num, out result);
			num = HXLDExtPara.LoadNew(proc, 2, num, out extParallels);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Extract parallel XLD polygons enclosing a homogeneous area.
		///   Instance represents: Input XLD parallels.
		/// </summary>
		/// <param name="image">Corresponding gray value image.</param>
		/// <param name="extParallels">Extended XLD parallels.</param>
		/// <param name="quality">Minimum quality factor (measure of parallelism). Default: 0.4</param>
		/// <param name="minGray">Minimum mean gray value. Default: 160</param>
		/// <param name="maxGray">Maximum mean gray value. Default: 220</param>
		/// <param name="maxStandard">Maximum allowed standard deviation. Default: 10.0</param>
		/// <returns>Modified XLD parallels.</returns>
		// Token: 0x06001CCD RID: 7373 RVA: 0x000B2288 File Offset: 0x000B0488
		public HXLDModPara ModParallelsXld(HImage image, out HXLDExtPara extParallels, double quality, int minGray, int maxGray, double maxStandard)
		{
			IntPtr proc = HalconAPI.PreCall(39);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreD(proc, 0, quality);
			HalconAPI.StoreI(proc, 1, minGray);
			HalconAPI.StoreI(proc, 2, maxGray);
			HalconAPI.StoreD(proc, 3, maxStandard);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HXLDModPara result;
			num = HXLDModPara.LoadNew(proc, 1, num, out result);
			num = HXLDExtPara.LoadNew(proc, 2, num, out extParallels);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Return information about the gray values of the area enclosed by XLD parallels.
		///   Instance represents: Input XLD Parallels.
		/// </summary>
		/// <param name="image">Corresponding gray value image.</param>
		/// <param name="qualityMin">Minimum quality factor.</param>
		/// <param name="qualityMax">Maximum quality factor.</param>
		/// <param name="grayMin">Minimum mean gray value.</param>
		/// <param name="grayMax">Maximum mean gray value.</param>
		/// <param name="standardMin">Minimum standard deviation.</param>
		/// <param name="standardMax">Maximum standard deviation.</param>
		// Token: 0x06001CCE RID: 7374 RVA: 0x000B2310 File Offset: 0x000B0510
		public void InfoParallelsXld(HImage image, out double qualityMin, out double qualityMax, out int grayMin, out int grayMax, out double standardMin, out double standardMax)
		{
			IntPtr proc = HalconAPI.PreCall(40);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out qualityMin);
			num = HalconAPI.LoadD(proc, 1, num, out qualityMax);
			num = HalconAPI.LoadI(proc, 2, num, out grayMin);
			num = HalconAPI.LoadI(proc, 3, num, out grayMax);
			num = HalconAPI.LoadD(proc, 4, num, out standardMin);
			num = HalconAPI.LoadD(proc, 5, num, out standardMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Calculate the difference of two object tuples.
		///   Instance represents: Object tuple 1.
		/// </summary>
		/// <param name="objectsSub">Object tuple 2.</param>
		/// <returns>Objects from Objects that are not part of ObjectsSub.</returns>
		// Token: 0x06001CCF RID: 7375 RVA: 0x000B23C0 File Offset: 0x000B05C0
		public HXLDPara ObjDiff(HXLDPara objectsSub)
		{
			IntPtr proc = HalconAPI.PreCall(573);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsSub);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsSub);
			return result;
		}

		/// <summary>
		///   Copy an iconic object in the HALCON database.
		///   Instance represents: Objects to be copied.
		/// </summary>
		/// <param name="index">Starting index of the objects to be copied. Default: 1</param>
		/// <param name="numObj">Number of objects to be copied or -1. Default: 1</param>
		/// <returns>Copied objects.</returns>
		// Token: 0x06001CD0 RID: 7376 RVA: 0x000B2418 File Offset: 0x000B0618
		public new HXLDPara CopyObj(int index, int numObj)
		{
			IntPtr proc = HalconAPI.PreCall(583);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.StoreI(proc, 1, numObj);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Concatenate two iconic object tuples.
		///   Instance represents: Object tuple 1.
		/// </summary>
		/// <param name="objects2">Object tuple 2.</param>
		/// <returns>Concatenated objects.</returns>
		// Token: 0x06001CD1 RID: 7377 RVA: 0x000B2470 File Offset: 0x000B0670
		public HXLDPara ConcatObj(HXLDPara objects2)
		{
			IntPtr proc = HalconAPI.PreCall(584);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Select objects from an object tuple.
		///   Instance represents: Input objects.
		/// </summary>
		/// <param name="index">Indices of the objects to be selected. Default: 1</param>
		/// <returns>Selected objects.</returns>
		// Token: 0x06001CD2 RID: 7378 RVA: 0x000B24C8 File Offset: 0x000B06C8
		public new HXLDPara SelectObj(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(587);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select objects from an object tuple.
		///   Instance represents: Input objects.
		/// </summary>
		/// <param name="index">Indices of the objects to be selected. Default: 1</param>
		/// <returns>Selected objects.</returns>
		// Token: 0x06001CD3 RID: 7379 RVA: 0x000B2520 File Offset: 0x000B0720
		public new HXLDPara SelectObj(int index)
		{
			IntPtr proc = HalconAPI.PreCall(587);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compare iconic objects regarding equality.
		///   Instance represents: Reference objects.
		/// </summary>
		/// <param name="objects2">Test objects.</param>
		/// <param name="epsilon">Maximum allowed difference between two gray values or  coordinates etc. Default: 0.0</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x06001CD4 RID: 7380 RVA: 0x000B2570 File Offset: 0x000B0770
		public int CompareObj(HXLDPara objects2, HTuple epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(588);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.Store(proc, 0, epsilon);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(epsilon);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compare iconic objects regarding equality.
		///   Instance represents: Reference objects.
		/// </summary>
		/// <param name="objects2">Test objects.</param>
		/// <param name="epsilon">Maximum allowed difference between two gray values or  coordinates etc. Default: 0.0</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x06001CD5 RID: 7381 RVA: 0x000B25D4 File Offset: 0x000B07D4
		public int CompareObj(HXLDPara objects2, double epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(588);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.StoreD(proc, 0, epsilon);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compare image objects regarding equality.
		///   Instance represents: Test objects.
		/// </summary>
		/// <param name="objects2">Comparative objects.</param>
		/// <returns>boolean result value.</returns>
		// Token: 0x06001CD6 RID: 7382 RVA: 0x000B2634 File Offset: 0x000B0834
		public int TestEqualObj(HXLDPara objects2)
		{
			IntPtr proc = HalconAPI.PreCall(591);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compute the mapping between the distorted image and the rectified image based upon the points of a regular grid.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="meshes">Output contours.</param>
		/// <param name="gridSpacing">Distance of the grid points in the rectified image.</param>
		/// <param name="rotation">Rotation to be applied to the point grid. Default: "auto"</param>
		/// <param name="row">Row coordinates of the grid points.</param>
		/// <param name="column">Column coordinates of the grid points.</param>
		/// <param name="mapType">Type of mapping. Default: "bilinear"</param>
		/// <returns>Image containing the mapping data.</returns>
		// Token: 0x06001CD7 RID: 7383 RVA: 0x000B268C File Offset: 0x000B088C
		public HImage GenGridRectificationMap(HImage image, out HXLDPara meshes, int gridSpacing, HTuple rotation, HTuple row, HTuple column, string mapType)
		{
			IntPtr proc = HalconAPI.PreCall(1159);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreI(proc, 0, gridSpacing);
			HalconAPI.Store(proc, 1, rotation);
			HalconAPI.Store(proc, 2, row);
			HalconAPI.Store(proc, 3, column);
			HalconAPI.StoreS(proc, 4, mapType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLDPara.LoadNew(proc, 2, num, out meshes);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Compute the mapping between the distorted image and the rectified image based upon the points of a regular grid.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="meshes">Output contours.</param>
		/// <param name="gridSpacing">Distance of the grid points in the rectified image.</param>
		/// <param name="rotation">Rotation to be applied to the point grid. Default: "auto"</param>
		/// <param name="row">Row coordinates of the grid points.</param>
		/// <param name="column">Column coordinates of the grid points.</param>
		/// <param name="mapType">Type of mapping. Default: "bilinear"</param>
		/// <returns>Image containing the mapping data.</returns>
		// Token: 0x06001CD8 RID: 7384 RVA: 0x000B2738 File Offset: 0x000B0938
		public HImage GenGridRectificationMap(HImage image, out HXLDPara meshes, int gridSpacing, string rotation, HTuple row, HTuple column, string mapType)
		{
			IntPtr proc = HalconAPI.PreCall(1159);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreI(proc, 0, gridSpacing);
			HalconAPI.StoreS(proc, 1, rotation);
			HalconAPI.Store(proc, 2, row);
			HalconAPI.Store(proc, 3, column);
			HalconAPI.StoreS(proc, 4, mapType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLDPara.LoadNew(proc, 2, num, out meshes);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Choose all contours or polygons containing a given point.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Line coordinate of the test point. Default: 100.0</param>
		/// <param name="column">Column coordinate of the test point. Default: 100.0</param>
		/// <returns>All contours or polygons containing the test point.</returns>
		// Token: 0x06001CD9 RID: 7385 RVA: 0x000B27DC File Offset: 0x000B09DC
		public new HXLDPara SelectXldPoint(HTuple row, HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1676);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Choose all contours or polygons containing a given point.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Line coordinate of the test point. Default: 100.0</param>
		/// <param name="column">Column coordinate of the test point. Default: 100.0</param>
		/// <returns>All contours or polygons containing the test point.</returns>
		// Token: 0x06001CDA RID: 7386 RVA: 0x000B2840 File Offset: 0x000B0A40
		public new HXLDPara SelectXldPoint(double row, double column)
		{
			IntPtr proc = HalconAPI.PreCall(1676);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select contours or polygons using shape features.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="features">Shape features to be checked. Default: "area"</param>
		/// <param name="operation">Operation type between the individual features. Default: "and"</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: 150.0</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: 99999.0</param>
		/// <returns>Contours or polygons fulfilling the condition(s).</returns>
		// Token: 0x06001CDB RID: 7387 RVA: 0x000B2898 File Offset: 0x000B0A98
		public new HXLDPara SelectShapeXld(HTuple features, string operation, HTuple min, HTuple max)
		{
			IntPtr proc = HalconAPI.PreCall(1678);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, features);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.Store(proc, 2, min);
			HalconAPI.Store(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(features);
			HalconAPI.UnpinTuple(min);
			HalconAPI.UnpinTuple(max);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select contours or polygons using shape features.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="features">Shape features to be checked. Default: "area"</param>
		/// <param name="operation">Operation type between the individual features. Default: "and"</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: 150.0</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: 99999.0</param>
		/// <returns>Contours or polygons fulfilling the condition(s).</returns>
		// Token: 0x06001CDC RID: 7388 RVA: 0x000B2914 File Offset: 0x000B0B14
		public new HXLDPara SelectShapeXld(string features, string operation, double min, double max)
		{
			IntPtr proc = HalconAPI.PreCall(1678);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, features);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.StoreD(proc, 2, min);
			HalconAPI.StoreD(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform the shape of contours or polygons.
		///   Instance represents: Contours or polygons to be transformed.
		/// </summary>
		/// <param name="type">Type of transformation. Default: "convex"</param>
		/// <returns>Transformed contours respectively polygons.</returns>
		// Token: 0x06001CDD RID: 7389 RVA: 0x000B2980 File Offset: 0x000B0B80
		public new HXLDPara ShapeTransXld(string type)
		{
			IntPtr proc = HalconAPI.PreCall(1689);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Insert objects into an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="objectsInsert">Object tuple to insert.</param>
		/// <param name="index">Index to insert objects.</param>
		/// <returns>Extended object tuple.</returns>
		// Token: 0x06001CDE RID: 7390 RVA: 0x000B29D0 File Offset: 0x000B0BD0
		public HXLDPara InsertObj(HXLDPara objectsInsert, int index)
		{
			IntPtr proc = HalconAPI.PreCall(2121);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsInsert);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsInsert);
			return result;
		}

		/// <summary>
		///   Remove objects from an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="index">Indices of the objects to be removed.</param>
		/// <returns>Remaining object tuple.</returns>
		// Token: 0x06001CDF RID: 7391 RVA: 0x000B2A30 File Offset: 0x000B0C30
		public new HXLDPara RemoveObj(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(2124);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove objects from an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="index">Indices of the objects to be removed.</param>
		/// <returns>Remaining object tuple.</returns>
		// Token: 0x06001CE0 RID: 7392 RVA: 0x000B2A88 File Offset: 0x000B0C88
		public new HXLDPara RemoveObj(int index)
		{
			IntPtr proc = HalconAPI.PreCall(2124);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Replaces one or more elements of an iconic object tuple.
		///   Instance represents: Iconic Input Object.
		/// </summary>
		/// <param name="objectsReplace">Element(s) to replace.</param>
		/// <param name="index">Index/Indices of elements to be replaced.</param>
		/// <returns>Tuple with replaced elements.</returns>
		// Token: 0x06001CE1 RID: 7393 RVA: 0x000B2AD8 File Offset: 0x000B0CD8
		public HXLDPara ReplaceObj(HXLDPara objectsReplace, HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(2125);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsReplace);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsReplace);
			return result;
		}

		/// <summary>
		///   Replaces one or more elements of an iconic object tuple.
		///   Instance represents: Iconic Input Object.
		/// </summary>
		/// <param name="objectsReplace">Element(s) to replace.</param>
		/// <param name="index">Index/Indices of elements to be replaced.</param>
		/// <returns>Tuple with replaced elements.</returns>
		// Token: 0x06001CE2 RID: 7394 RVA: 0x000B2B3C File Offset: 0x000B0D3C
		public HXLDPara ReplaceObj(HXLDPara objectsReplace, int index)
		{
			IntPtr proc = HalconAPI.PreCall(2125);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsReplace);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDPara result;
			num = HXLDPara.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsReplace);
			return result;
		}
	}
}
